home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / make / icmake-6.000 / icmake-6 / icmake / comp / lexer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-08  |  50.8 KB  |  1,777 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* scanner skeleton version:
  4.  * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $
  5.  */
  6.  
  7. #define ICCE_MODIFICATIONS                  /* look below for ICCE_MODIFIC */
  8.  
  9. #ifdef MSDOS
  10. #define __STDC__
  11. #endif
  12.  
  13. #define FLEX_SCANNER
  14.  
  15. #include <stdio.h>
  16.  
  17.  
  18. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  19. #ifdef c_plusplus
  20. #ifndef __cplusplus
  21. #define __cplusplus
  22. #endif
  23. #endif
  24.  
  25.  
  26. #ifdef __cplusplus
  27.  
  28. #include <stdlib.h>
  29.  
  30. #ifdef ICCE_MODIFICATIONS
  31. /*************************************************************************/
  32.                                             /* ICCE: BEGIN OF MODIFICATIONS */
  33.                                             /* (FBB, 12/06/93) */
  34.  
  35. #include <io.h>                             /*  contains fileno()'s prototype */
  36.  
  37. #define fileno  _fileno                     /* Ms C 7.00 name alterations */
  38. #define read    _read
  39.  
  40. #else
  41. #include <osfcn.h>
  42. #endif                                      /* ICCE: END OF MODIFICATIONS */
  43. /*************************************************************************/
  44.  
  45. /* use prototypes in function declarations */
  46. #define YY_USE_PROTOS
  47.  
  48. /* the "const" storage-class-modifier is valid */
  49. #define YY_USE_CONST
  50.  
  51. #else   /* ! __cplusplus */
  52.  
  53. #ifdef __STDC__
  54.  
  55. #ifdef __GNUC__
  56. #include <stddef.h>
  57. void *malloc( size_t );
  58. void free( void* );
  59. #else
  60. #include <stdlib.h>
  61. #endif  /* __GNUC__ */
  62.  
  63. #define YY_USE_PROTOS
  64. #define YY_USE_CONST
  65.  
  66. #endif  /* __STDC__ */
  67. #endif  /* ! __cplusplus */
  68.  
  69.  
  70. #ifdef __TURBOC__
  71. #define YY_USE_CONST
  72. #endif
  73.  
  74.  
  75. #ifndef YY_USE_CONST
  76. #define const
  77. #endif
  78.  
  79.  
  80. #ifdef YY_USE_PROTOS
  81. #define YY_PROTO(proto) proto
  82. #else
  83. #define YY_PROTO(proto) ()
  84. /* we can't get here if it's an ANSI C compiler, or a C++ compiler,
  85.  * so it's got to be a K&R compiler, and therefore there's no standard
  86.  * place from which to include these definitions
  87.  */
  88. char *malloc();
  89. int free();
  90. int read();
  91. #endif
  92.  
  93.  
  94. /* amount of stuff to slurp up with each read */
  95. #ifndef YY_READ_BUF_SIZE
  96. #define YY_READ_BUF_SIZE 8192
  97. #endif
  98.  
  99. /* returned upon end-of-file */
  100. #define YY_END_TOK 0
  101.  
  102. /* copy whatever the last rule matched to the standard output */
  103.  
  104. /* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
  105. /* this used to be an fputs(), but since the string might contain NUL's,
  106.  * we now use fwrite()
  107.  */
  108. #define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
  109.  
  110. /* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  111.  * is returned in "result".
  112.  */
  113. #define YY_INPUT(buf,result,max_size) \
  114.         if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
  115.             YY_FATAL_ERROR( "read() in flex scanner failed" );
  116. #define YY_NULL 0
  117.  
  118. /* no semi-colon after return; correct usage is to write "yyterminate();" -
  119.  * we don't want an extra ';' after the "return" because that will cause
  120.  * some compilers to complain about unreachable statements.
  121.  */
  122. #define yyterminate() return ( YY_NULL )
  123.  
  124. /* report a fatal error */
  125.  
  126. /* The funky do-while is used to turn this macro definition into
  127.  * a single C statement (which needs a semi-colon terminator).
  128.  * This avoids problems with code like:
  129.  *
  130.  *      if ( something_happens )
  131.  *              YY_FATAL_ERROR( "oops, the something happened" );
  132.  *      else
  133.  *              everything_okay();
  134.  *
  135.  * Prior to using the do-while the compiler would get upset at the
  136.  * "else" because it interpreted the "if" statement as being all
  137.  * done when it reached the ';' after the YY_FATAL_ERROR() call.
  138.  */
  139.  
  140. #define YY_FATAL_ERROR(msg) \
  141.         do \
  142.                 { \
  143.                 (void) fputs( msg, stderr ); \
  144.                 (void) putc( '\n', stderr ); \
  145.                 exit( 1 ); \
  146.                 } \
  147.         while ( 0 )
  148.  
  149. /* default yywrap function - always treat EOF as an EOF */
  150. #define yywrap() 1
  151.  
  152. /* enter a start condition.  This macro really ought to take a parameter,
  153.  * but we do it the disgusting crufty way forced on us by the ()-less
  154.  * definition of BEGIN
  155.  */
  156. #define BEGIN yy_start = 1 + 2 *
  157.  
  158. /* action number for EOF rule of a given start state */
  159. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  160.  
  161. /* special action meaning "start processing a new file" */
  162. #define YY_NEW_FILE \
  163.         do \
  164.                 { \
  165.                 yy_init_buffer( yy_current_buffer, yyin ); \
  166.                 yy_load_buffer_state(); \
  167.                 } \
  168.         while ( 0 )
  169.  
  170. /* default declaration of generated scanner - a define so the user can
  171.  * easily add parameters
  172.  */
  173. #define YY_DECL int yylex YY_PROTO(( void ))
  174.  
  175. /* code executed at the end of each rule */
  176. #define YY_BREAK break;
  177.  
  178. #define YY_END_OF_BUFFER_CHAR 0
  179.  
  180. #ifndef YY_BUF_SIZE
  181. #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
  182. #endif
  183.  
  184. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  185.  
  186. #define YY_CHAR char
  187. # line 1 "lexer"
  188. #define INITIAL 0
  189. # line 2 "lexer"
  190. /*
  191.                                    L E X E R
  192. */
  193.  
  194. #include "iccomp.h"
  195. #include "parser.h"
  196.  
  197. #undef  YY_INPUT
  198. #define YY_INPUT(buf,result,max_size) result = yylex_input(buf, max_size);
  199.  
  200. #define str 1
  201. # line 16 "lexer"
  202.  
  203. /* done after the current pattern has been matched and before the
  204.  * corresponding action - sets up yytext
  205.  */
  206. #define YY_DO_BEFORE_ACTION \
  207.         yytext = yy_bp; \
  208.     yyleng = yy_cp - yy_bp; \
  209.         yy_hold_char = *yy_cp; \
  210.         *yy_cp = '\0'; \
  211.         yy_c_buf_p = yy_cp;
  212.  
  213. #define EOB_ACT_CONTINUE_SCAN 0
  214. #define EOB_ACT_END_OF_FILE 1
  215. #define EOB_ACT_LAST_MATCH 2
  216.  
  217. /* return all but the first 'n' matched characters back to the input stream */
  218. #define yyless(n) \
  219.         do \
  220.                 { \
  221.                 /* undo effects of setting up yytext */ \
  222.                 *yy_cp = yy_hold_char; \
  223.                 yy_c_buf_p = yy_cp = yy_bp + n; \
  224.                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  225.                 } \
  226.         while ( 0 )
  227.  
  228. #define unput(c) yyunput( c, yytext )
  229.  
  230.  
  231. struct yy_buffer_state
  232.     {
  233.     FILE *yy_input_file;
  234.  
  235.     YY_CHAR *yy_ch_buf;         /* input buffer */
  236.     YY_CHAR *yy_buf_pos;        /* current position in input buffer */
  237.  
  238.     /* size of input buffer in bytes, not including room for EOB characters*/
  239.     int yy_buf_size;
  240.  
  241.     /* number of characters read into yy_ch_buf, not including EOB characters */
  242.     int yy_n_chars;
  243.  
  244.     int yy_eof_status;          /* whether we've seen an EOF on this buffer */
  245. #define EOF_NOT_SEEN 0
  246.     /* "pending" happens when the EOF has been seen but there's still
  247.      * some text process
  248.      */
  249. #define EOF_PENDING 1
  250. #define EOF_DONE 2
  251.     };
  252.  
  253. static YY_BUFFER_STATE yy_current_buffer;
  254.  
  255. /* we provide macros for accessing buffer states in case in the
  256.  * future we want to put the buffer states in a more general
  257.  * "scanner state"
  258.  */
  259. #define YY_CURRENT_BUFFER yy_current_buffer
  260.  
  261.  
  262. /* yy_hold_char holds the character lost when yytext is formed */
  263. static YY_CHAR yy_hold_char;
  264.  
  265. static int yy_n_chars;          /* number of characters read into yy_ch_buf */
  266.  
  267.  
  268.  
  269. #ifndef YY_USER_ACTION
  270. #define YY_USER_ACTION
  271. #endif
  272.  
  273. #ifndef YY_USER_INIT
  274. #define YY_USER_INIT
  275. #endif
  276.  
  277. extern YY_CHAR *yytext;
  278. extern int yyleng;
  279. extern FILE *yyin, *yyout;
  280.  
  281. YY_CHAR *yytext;
  282. int yyleng;
  283.  
  284. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  285.  
  286. #define YY_END_OF_BUFFER 95
  287. typedef int yy_state_type;
  288. static const short int yy_accept[322] =
  289.     {   0,
  290.         0,    0,    0,    0,   95,   93,    4,    5,   93,    7,
  291.        93,   93,   93,   93,   93,   93,   93,   77,   93,   93,
  292.        93,   92,   92,   92,   92,   93,   92,   92,   92,   92,
  293.        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  294.        92,   92,   92,   93,    6,    1,    3,    1,   72,   62,
  295.        70,   64,    0,   61,   57,   63,   58,   60,   59,   77,
  296.        76,   73,   71,   74,   75,   92,   92,   82,   92,   92,
  297.        92,   66,   92,   92,   92,   92,   92,   92,   92,   92,
  298.        92,   92,   92,   92,   35,   92,   92,   92,   92,   92,
  299.        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  300.  
  301.        65,   69,    6,    2,    8,   67,   68,   78,   92,   92,
  302.        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  303.        92,   92,   92,   92,   92,   92,   92,   34,   92,   92,
  304.        37,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  305.        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  306.        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  307.        92,   92,   92,   92,   26,   92,   28,   29,   92,   32,
  308.        92,   92,   92,   92,   92,   25,   38,   92,   92,   92,
  309.        92,   92,   92,   92,   46,   92,   92,   92,   92,   92,
  310.        92,   36,   92,   92,   89,   85,   92,   92,   92,   92,
  311.  
  312.        92,   92,   92,   92,   92,   92,   92,   92,   11,   12,
  313.        92,   13,   92,   92,   92,   92,   92,   33,   92,   92,
  314.        92,   92,   23,   92,   92,   55,   40,   92,   92,   92,
  315.        92,   92,   92,   92,   92,   92,   92,   92,   54,   92,
  316.        81,   92,   92,   92,   92,   92,   92,   92,   92,   92,
  317.        92,   92,   92,   92,   92,   92,   92,   31,   92,   92,
  318.        92,   92,   24,   92,   41,   42,   43,   44,   47,   48,
  319.        49,   51,   50,   52,   53,   92,   92,   79,   92,   91,
  320.        83,   80,   86,   88,   92,    9,   10,   92,   15,   14,
  321.        27,   30,   19,   92,   21,   92,   92,   92,   56,   87,
  322.  
  323.        92,   90,   92,   92,   92,   20,   22,   39,   92,   84,
  324.        92,   92,   92,   92,   92,   17,   92,   45,   16,   18,
  325.         0
  326.     } ;
  327.  
  328. static const YY_CHAR yy_ec[128] =
  329.     {   0,
  330.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  331.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  332.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  333.         1,    2,    4,    5,    6,    1,    7,    8,    9,    1,
  334.         1,   10,   11,    1,   12,    1,   13,   14,   14,   14,
  335.        14,   14,   14,   14,   14,   14,   14,    1,    1,   15,
  336.        16,   17,    1,    1,   18,   19,   20,   21,   22,   23,
  337.        24,   25,   26,   27,   28,   29,   27,   30,   31,   32,
  338.        27,   33,   34,   35,   36,   27,   37,   38,   27,   27,
  339.         1,   39,    1,   40,   41,    1,   42,   43,   44,   45,
  340.  
  341.        46,   47,   48,   49,   50,   27,   51,   52,   53,   54,
  342.        55,   56,   27,   57,   58,   59,   60,   61,   62,   63,
  343.        64,   65,    1,   66,    1,    1,    1
  344.     } ;
  345.  
  346. static const YY_CHAR yy_meta[67] =
  347.     {   0,
  348.         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    3,    1,    1,    1,    3,    3,    3,
  350.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  351.         3,    3,    3,    3,    3,    3,    3,    3,    1,    1,
  352.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  353.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  354.         3,    3,    3,    3,    3,    1
  355.     } ;
  356.  
  357. static const short int yy_base[327] =
  358.     {   0,
  359.         0,  345,   62,   63,  350,  352,  352,  352,  333,  352,
  360.       332,   61,    0,  331,   59,   60,  330,  331,   58,  328,
  361.        62,    0,   57,  302,  301,  325,   24,  283,   35,   41,
  362.        35,  293,   42,  288,  295,  290,  283,   35,  288,   47,
  363.       278,  283,  276,   55,    0,  352,  352,    0,  352,  352,
  364.       352,  352,  321,  352,  352,  352,  352,  352,  352,  315,
  365.       312,  352,  352,  352,  311,    0,  303,    0,   82,   79,
  366.       299,  352,  276,  279,  276,   68,  276,  271,   62,   68,
  367.       273,  261,  260,  257,    0,  256,  256,  262,  250,  266,
  368.       260,  250,  249,  242,   70,  263,  247,  254,  253,  242,
  369.  
  370.       352,  352,    0,  352,  352,  352,  352,    0,  272,  274,
  371.       273,  262,  272,  265,  100,   66,  245,  252,  239,  242,
  372.        70,  236,  237,  243,  244,   72,  228,    0,  236,   91,
  373.         0,  226,  238,  237,  236,  227,  234,  219,  232,  218,
  374.        84,  218,  216,  229,  221,  218,  242,  237,  240,  249,
  375.       245,  246,  227,  118,  242,  230,  216,  219,  210,  208,
  376.       210,  200,  210,  213,    0,  208,    0,  193,  193,    0,
  377.       193,  196,   99,  200,  198,    0,    0,  195,  189,  188,
  378.       185,  189,  185,  186,    0,  186,   78,  184,  182,  178,
  379.       190,    0,  189,  186,    0,    0,  211,  211,  211,  205,
  380.  
  381.       207,  203,  201,  204,  207,  198,  181,  172,    0,    0,
  382.       175,    0,  178,  169,  164,  158,  158,    0,  156,  172,
  383.       150,  170,    0,  166,  160,    0,    0,  162,  147,  153,
  384.       159,  157,  150,  146,  151,  144,  143,  146,    0,  152,
  385.         0,  171,  168,  173,  174,  160,  159,  167,  169,  154,
  386.       143,  135,  145,  140,  132,  124,  136,    0,  134,  122,
  387.       120,  119,    0,  119,    0,    0,    0,  124,    0,    0,
  388.         0,    0,    0,    0,    0,  117,  138,    0,  148,    0,
  389.         0,    0,    0,    0,  140,    0,    0,  107,    0,    0,
  390.         0,    0,    0,  115,    0,  111,  100,  108,    0,    0,
  391.  
  392.       129,    0,  114,   91,  110,    0,    0,    0,   90,    0,
  393.        88,   82,   69,   67,   71,    0,   45,    0,    0,    0,
  394.       352,  163,  166,   83,  169,  172
  395.     } ;
  396.  
  397. static const short int yy_def[327] =
  398.     {   0,
  399.       321,    1,  322,  322,  321,  321,  321,  321,  321,  321,
  400.       321,  321,  323,  321,  321,  321,  321,  321,  321,  321,
  401.       321,  324,  324,  324,  324,  321,  324,  324,  324,  324,
  402.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  403.       324,  324,  324,  321,  325,  321,  321,  326,  321,  321,
  404.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  405.       321,  321,  321,  321,  321,  324,  324,  324,  324,  324,
  406.       324,  321,  324,  324,  324,  324,  324,  324,  324,  324,
  407.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  408.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  409.  
  410.       321,  321,  325,  321,  321,  321,  321,  324,  324,  324,
  411.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  412.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  413.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  414.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  415.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  416.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  417.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  418.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  419.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  420.  
  421.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  422.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  423.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  424.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  425.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  426.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  427.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  428.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  429.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  430.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  431.  
  432.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  433.       324,  324,  324,  324,  324,  324,  324,  324,  324,  324,
  434.         0,  321,  321,  321,  321,  321
  435.     } ;
  436.  
  437. static const short int yy_nxt[419] =
  438.     {   0,
  439.         6,    7,    8,    9,   10,    6,   11,   12,   13,   14,
  440.        15,   16,   17,   18,   19,   20,   21,   22,   22,   22,
  441.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  442.        23,   24,   22,   25,   22,   22,   22,   22,    6,   26,
  443.        22,   27,   28,   29,   22,   30,   31,   32,   22,   33,
  444.        22,   34,   35,   36,   37,   38,   39,   40,   22,   22,
  445.        41,   42,   22,   43,   22,   44,   47,   47,   51,   55,
  446.       101,   57,   61,   62,   56,   58,   52,   64,   65,   67,
  447.        73,   74,   81,   76,   78,   66,   68,   77,   85,   82,
  448.        83,   91,   79,  320,   92,   86,   94,   69,  113,  109,
  449.  
  450.        48,   48,  110,   80,  111,   95,   96,  123,  114,  119,
  451.        97,  140,  120,  125,  157,  112,  319,  126,  163,  124,
  452.       102,  153,  154,  233,  158,  318,  141,  317,  164,  169,
  453.       170,  173,  155,  186,  174,  187,  156,  202,  203,  234,
  454.       316,  220,  188,  189,  221,  315,  175,  314,  176,  303,
  455.       204,  313,  304,  312,  222,  311,  310,  309,  308,  307,
  456.       306,  302,  305,   46,   46,   46,   53,  301,   53,  103,
  457.       300,  103,  104,  299,  104,  298,  297,  296,  295,  294,
  458.       293,  292,  291,  290,  289,  288,  287,  286,  285,  284,
  459.       283,  282,  281,  280,  279,  278,  277,  276,  275,  274,
  460.  
  461.       273,  272,  271,  270,  269,  268,  267,  266,  265,  264,
  462.       263,  262,  261,  260,  259,  258,  257,  256,  255,  254,
  463.       253,  252,  251,  250,  249,  248,  247,  246,  245,  244,
  464.       243,  242,  241,  240,  239,  238,  237,  236,  235,  232,
  465.       231,  230,  229,  228,  227,  226,  225,  224,  223,  219,
  466.       218,  217,  216,  215,  214,  213,  212,  211,  210,  209,
  467.       208,  207,  206,  205,  201,  200,  199,  198,  197,  196,
  468.       195,  194,  193,  192,  191,  190,  185,  184,  183,  182,
  469.       181,  180,  179,  178,  177,  172,  171,  168,  167,  166,
  470.       165,  162,  161,  160,  159,  152,  151,  150,  149,  148,
  471.  
  472.       147,  146,  145,  144,  143,  142,  139,  138,  137,  136,
  473.       135,  134,  133,  132,  131,  130,  129,  128,  127,  122,
  474.       121,  118,  117,  116,  115,  108,  107,  106,   60,  105,
  475.       100,   99,   98,   93,   90,   89,   88,   87,   84,   75,
  476.        72,   71,   70,   63,   60,   59,   54,   50,   49,  321,
  477.        45,    5,  321,  321,  321,  321,  321,  321,  321,  321,
  478.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  479.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  480.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  481.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  482.  
  483.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  484.       321,  321,  321,  321,  321,  321,  321,  321
  485.     } ;
  486.  
  487. static const short int yy_chk[419] =
  488.     {   0,
  489.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  490.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  491.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  492.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  493.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  494.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  495.         1,    1,    1,    1,    1,    1,    3,    4,   12,   15,
  496.        44,   16,   19,   19,   15,   16,   12,   21,   21,   23,
  497.        27,   27,   31,   29,   30,  324,   23,   29,   33,   31,
  498.        31,   38,   30,  317,   38,   33,   40,   23,   70,   69,
  499.  
  500.         3,    4,   69,   30,   69,   40,   40,   79,   70,   76,
  501.        40,   95,   76,   80,  116,   69,  315,   80,  121,   79,
  502.        44,  115,  115,  187,  116,  314,   95,  313,  121,  126,
  503.       126,  130,  115,  141,  130,  141,  115,  154,  154,  187,
  504.       312,  173,  141,  141,  173,  311,  130,  309,  130,  288,
  505.       154,  305,  288,  304,  173,  303,  301,  298,  297,  296,
  506.       294,  285,  288,  322,  322,  322,  323,  279,  323,  325,
  507.       277,  325,  326,  276,  326,  268,  264,  262,  261,  260,
  508.       259,  257,  256,  255,  254,  253,  252,  251,  250,  249,
  509.       248,  247,  246,  245,  244,  243,  242,  240,  238,  237,
  510.  
  511.       236,  235,  234,  233,  232,  231,  230,  229,  228,  225,
  512.       224,  222,  221,  220,  219,  217,  216,  215,  214,  213,
  513.       211,  208,  207,  206,  205,  204,  203,  202,  201,  200,
  514.       199,  198,  197,  194,  193,  191,  190,  189,  188,  186,
  515.       184,  183,  182,  181,  180,  179,  178,  175,  174,  172,
  516.       171,  169,  168,  166,  164,  163,  162,  161,  160,  159,
  517.       158,  157,  156,  155,  153,  152,  151,  150,  149,  148,
  518.       147,  146,  145,  144,  143,  142,  140,  139,  138,  137,
  519.       136,  135,  134,  133,  132,  129,  127,  125,  124,  123,
  520.       122,  120,  119,  118,  117,  114,  113,  112,  111,  110,
  521.  
  522.       109,  100,   99,   98,   97,   96,   94,   93,   92,   91,
  523.        90,   89,   88,   87,   86,   84,   83,   82,   81,   78,
  524.        77,   75,   74,   73,   71,   67,   65,   61,   60,   53,
  525.        43,   42,   41,   39,   37,   36,   35,   34,   32,   28,
  526.        26,   25,   24,   20,   18,   17,   14,   11,    9,    5,
  527.         2,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  528.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  529.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  530.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  531.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  532.  
  533.       321,  321,  321,  321,  321,  321,  321,  321,  321,  321,
  534.       321,  321,  321,  321,  321,  321,  321,  321
  535.     } ;
  536.  
  537. static yy_state_type yy_last_accepting_state;
  538. static YY_CHAR *yy_last_accepting_cpos;
  539.  
  540. /* the intent behind this definition is that it'll catch
  541.  * any uses of REJECT which flex missed
  542.  */
  543. #define REJECT reject_used_but_not_detected
  544. #define yymore() yymore_used_but_not_detected
  545. #define YY_MORE_ADJ 0
  546.  
  547. /* these variables are all declared out here so that section 3 code can
  548.  * manipulate them
  549.  */
  550. /* points to current character in buffer */
  551. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  552. /* ICCE MOD : static int yy_init = 1;            whether we need to initialize */
  553. int yy_init = 1;
  554. static int yy_start = 0;        /* start state number */
  555.  
  556. /* flag which is used to allow yywrap()'s to do buffer switches
  557.  * instead of setting up a fresh yyin.  A bit of a hack ...
  558.  */
  559. static int yy_did_buffer_switch_on_eof;
  560.  
  561. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  562. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  563. static int yy_get_next_buffer YY_PROTO(( void ));
  564. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  565. void yyrestart YY_PROTO(( FILE *input_file ));
  566. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  567. void yy_load_buffer_state YY_PROTO(( void ));
  568. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  569. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  570. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  571.  
  572. #define yy_new_buffer yy_create_buffer
  573.  
  574. #ifdef __cplusplus
  575. static int yyinput YY_PROTO(( void ));
  576. #else
  577. static int input YY_PROTO(( void ));
  578. #endif
  579.  
  580. YY_DECL
  581.     {
  582.     register yy_state_type yy_current_state;
  583.     register YY_CHAR *yy_cp, *yy_bp;
  584.     register int yy_act;
  585.  
  586.  
  587.  
  588.  
  589.     if ( yy_init )
  590.         {
  591.         YY_USER_INIT;
  592.  
  593.         if ( ! yy_start )
  594.             yy_start = 1;       /* first start state */
  595.  
  596.         if ( ! yyin )
  597.             yyin = stdin;
  598.  
  599.         if ( ! yyout )
  600.             yyout = stdout;
  601.  
  602.         if ( yy_current_buffer )
  603.             yy_init_buffer( yy_current_buffer, yyin );
  604.         else
  605.             yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  606.  
  607.         yy_load_buffer_state();
  608.  
  609.         yy_init = 0;
  610.         }
  611.  
  612.     while ( 1 )         /* loops until end-of-file is reached */
  613.         {
  614.         yy_cp = yy_c_buf_p;
  615.  
  616.         /* support of yytext */
  617.         *yy_cp = yy_hold_char;
  618.  
  619.         /* yy_bp points to the position in yy_ch_buf of the start of the
  620.          * current run.
  621.          */
  622.         yy_bp = yy_cp;
  623.  
  624.     yy_current_state = yy_start;
  625.     if ( yy_bp[-1] == '\n' )
  626.         ++yy_current_state;
  627. yy_match:
  628.     do
  629.         {
  630.         register YY_CHAR yy_c = yy_ec[*yy_cp];
  631.         if ( yy_accept[yy_current_state] )
  632.         {
  633.         yy_last_accepting_state = yy_current_state;
  634.         yy_last_accepting_cpos = yy_cp;
  635.         }
  636.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  637.         {
  638.         yy_current_state = yy_def[yy_current_state];
  639.         if ( yy_current_state >= 322 )
  640.             yy_c = yy_meta[yy_c];
  641.         }
  642.         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  643.         ++yy_cp;
  644.         }
  645.     while ( yy_current_state != 321 );
  646.     yy_cp = yy_last_accepting_cpos;
  647.     yy_current_state = yy_last_accepting_state;
  648.  
  649. yy_find_action:
  650.     yy_act = yy_accept[yy_current_state];
  651.  
  652.         YY_DO_BEFORE_ACTION;
  653.         YY_USER_ACTION;
  654.  
  655. do_action:      /* this label is used only to access EOF actions */
  656.  
  657.  
  658.         switch ( yy_act )
  659.             {
  660.         case 0: /* must backtrack */
  661.         /* undo the effects of YY_DO_BEFORE_ACTION */
  662.         *yy_cp = yy_hold_char;
  663.         yy_cp = yy_last_accepting_cpos;
  664.         yy_current_state = yy_last_accepting_state;
  665.         goto yy_find_action;
  666.  
  667. case 1:
  668. # line 19 "lexer"
  669. case 2:
  670. # line 19 "lexer"
  671. {
  672.                             strcat(string, yytext);
  673.                         }
  674.     YY_BREAK
  675. case 3:
  676. # line 22 "lexer"
  677. {
  678.                             BEGIN 0;
  679.                             if (!stresc(string))
  680.                                 semantic("illegal escape sequence in string");
  681.                             return(STRING);
  682.                         }
  683.     YY_BREAK
  684. case 4:
  685. # line 28 "lexer"
  686. ;
  687.     YY_BREAK
  688. case 5:
  689. # line 29 "lexer"
  690. yylineno++;
  691.     YY_BREAK
  692. case 6:
  693. # line 30 "lexer"
  694. {
  695.                             change_file(yytext + 1);
  696.                         }
  697.     YY_BREAK
  698. case 7:
  699. # line 33 "lexer"
  700. {
  701.                             string[0] = 0; BEGIN str;
  702.                         }
  703.     YY_BREAK
  704. case 8:
  705. # line 36 "lexer"
  706. {
  707.                             sprintf(string, "%d%c", yytext[1], 0);
  708.                             return(NUMBER);
  709.                         }
  710.     YY_BREAK
  711. case 9:
  712. # line 40 "lexer"
  713. {
  714.                             yylval.type = f_arg_head;
  715.                             return(ARG_HEAD);
  716.                         }
  717.     YY_BREAK
  718. case 10:
  719. # line 44 "lexer"
  720. {
  721.                             yylval.type = f_arg_tail;
  722.                             return(ARG_TAIL);
  723.                         }
  724.     YY_BREAK
  725. case 11:
  726. # line 48 "lexer"
  727. {                   /* ascii_int may become ascii_str */
  728.                             yylval.type = f_ascii_int;
  729.                             return(ASCII);
  730.                         }
  731.     YY_BREAK
  732. case 12:
  733. # line 52 "lexer"
  734. {
  735.                             return(BREAK);
  736.                         }
  737.     YY_BREAK
  738. case 13:
  739. # line 55 "lexer"
  740. {
  741.                             yylval.type = f_chdir;
  742.                             return(CHDIR);
  743.                         }
  744.     YY_BREAK
  745. case 14:
  746. # line 59 "lexer"
  747. {
  748.                             yylval.type = f_cmd_tail;
  749.                             return(CMD_TAIL);
  750.                         }
  751.     YY_BREAK
  752. case 15:
  753. # line 63 "lexer"
  754. {
  755.                             yylval.type = f_cmd_head;
  756.                             return(CMD_HEAD);
  757.                         }
  758.     YY_BREAK
  759. case 16:
  760. # line 67 "lexer"
  761. {
  762.                             yylval.type = f_c_base;
  763.                             return(C_BASE);
  764.                         }
  765.     YY_BREAK
  766. case 17:
  767. # line 71 "lexer"
  768. {
  769.                             yylval.type = f_c_ext;
  770.                             return(C_EXT);
  771.                         }
  772.     YY_BREAK
  773. case 18:
  774. # line 75 "lexer"
  775. {
  776.                             yylval.type = f_c_path;
  777.                             return(C_PATH);
  778.                         }
  779.     YY_BREAK
  780. case 19:
  781. # line 79 "lexer"
  782. {
  783.                             yylval.type = f_fprintf;
  784.                             return(FPRINTF);
  785.                         }
  786.     YY_BREAK
  787. case 20:
  788. # line 83 "lexer"
  789. {
  790.                             yylval.type = f_g_base;
  791.                             return(G_BASE);
  792.                         }
  793.     YY_BREAK
  794. case 21:
  795. # line 87 "lexer"
  796. {
  797.                             yylval.type = f_g_ext;
  798.                             return(G_EXT);
  799.                         }
  800.     YY_BREAK
  801. case 22:
  802. # line 91 "lexer"
  803. {
  804.                             yylval.type = f_g_path;
  805.                             return(G_PATH);
  806.                         }
  807.     YY_BREAK
  808. case 23:
  809. # line 95 "lexer"
  810. {
  811.                             yylval.type = f_getch;
  812.                             return(GETCH);
  813.                         }
  814.     YY_BREAK
  815. case 24:
  816. # line 99 "lexer"
  817. {
  818.                             yylval.type = f_getpid;
  819.                             return(GETPID);
  820.                         }
  821.     YY_BREAK
  822. case 25:
  823. # line 103 "lexer"
  824. {
  825.                             yylval.type = f_gets;
  826.                             return(GETS);
  827.                         }
  828.     YY_BREAK
  829. case 26:
  830. # line 107 "lexer"
  831. {
  832.                             yylval.type = f_echo;
  833.                             return(M_ECHO);
  834.                         }
  835.     YY_BREAK
  836. case 27:
  837. # line 111 "lexer"
  838. {
  839.                             yylval.type = f_element;
  840.                             return(ELEMENT);
  841.                         }
  842.     YY_BREAK
  843. case 28:
  844. # line 115 "lexer"
  845. {
  846.                             return(ELSE);
  847.                         }
  848.     YY_BREAK
  849. case 29:
  850. # line 118 "lexer"
  851. {
  852.                             yylval.type = f_exec;
  853.                             return(EXEC);
  854.                         }
  855.     YY_BREAK
  856. case 30:
  857. # line 122 "lexer"
  858. {
  859.                             yylval.type = f_execute;
  860.                             return(EXECUTE);
  861.                         }
  862.     YY_BREAK
  863. case 31:
  864. # line 126 "lexer"
  865. {
  866.                             yylval.type = f_exists;
  867.                             return(EXISTS);
  868.                         }
  869.     YY_BREAK
  870. case 32:
  871. # line 130 "lexer"
  872. {
  873.                             yylval.type = op_exit;
  874.                             return(EXIT);
  875.                         }
  876.     YY_BREAK
  877. case 33:
  878. # line 134 "lexer"
  879. {
  880.                             yylval.type = f_fgets;
  881.                             return (FGETS);
  882.                         }
  883.     YY_BREAK
  884. case 34:
  885. # line 138 "lexer"
  886. {
  887.                             return(FOR);
  888.                         }
  889.     YY_BREAK
  890. case 35:
  891. # line 141 "lexer"
  892. {
  893.                             return(IF);
  894.                         }
  895.     YY_BREAK
  896. case 36:
  897. # line 144 "lexer"
  898. {
  899.                             yylval.type = 0;    /* 0 == void */
  900.                             return (VOID);
  901.                         }
  902.     YY_BREAK
  903. case 37:
  904. # line 148 "lexer"
  905. {
  906.                             yylval.type = e_int;
  907.                             return(INT);
  908.                         }
  909.     YY_BREAK
  910. case 38:
  911. # line 152 "lexer"
  912. {
  913.                             yylval.type = e_list;
  914.                             return(LIST);
  915.                         }
  916.     YY_BREAK
  917. case 39:
  918. # line 156 "lexer"
  919. {
  920.                             yylval.type = f_makelist;
  921.                             return(MAKELIST);
  922.                         }
  923.     YY_BREAK
  924. case 40:
  925. # line 160 "lexer"
  926. {
  927.                             yylval.type = op_older;
  928.                             return(OLDER);
  929.                         }
  930.     YY_BREAK
  931. case 41:
  932. # line 164 "lexer"
  933. {
  934.                             yylval.type = f_printf;
  935.                             return(PRINTF);
  936.                         }
  937.     YY_BREAK
  938. case 42:
  939. # line 168 "lexer"
  940. {
  941.                             yylval.type = f_putenv;
  942.                             return (PUTENV);
  943.                         }
  944.     YY_BREAK
  945. case 43:
  946. # line 172 "lexer"
  947. {
  948.                             yylval.type = op_ret;
  949.                             return(RETURN);
  950.                         }
  951.     YY_BREAK
  952. case 44:
  953. # line 177 "lexer"
  954. case 45:
  955. # line 177 "lexer"
  956. {
  957.                             yylval.type = f_sizeoflist;
  958.                             return(SIZEOFLIST);
  959.                         }
  960.     YY_BREAK
  961. case 46:
  962. # line 181 "lexer"
  963. {
  964.                             yylval.type = f_stat;
  965.                             return (STAT);
  966.                         }
  967.     YY_BREAK
  968. case 47:
  969. # line 185 "lexer"
  970. {
  971.                             yylval.type = e_str;
  972.                             return(STRINGTYPE);
  973.                         }
  974.     YY_BREAK
  975. case 48:
  976. # line 189 "lexer"
  977. {
  978.                             yylval.type = f_strlen;
  979.                             return(STRLEN);
  980.                         }
  981.     YY_BREAK
  982. case 49:
  983. # line 193 "lexer"
  984. {
  985.                             yylval.type = f_strlwr;
  986.                             return(STRLWR);
  987.                         }
  988.     YY_BREAK
  989. case 50:
  990. # line 197 "lexer"
  991. {
  992.                             yylval.type = f_strupr;
  993.                             return(STRUPR);
  994.                         }
  995.     YY_BREAK
  996. case 51:
  997. # line 201 "lexer"
  998. {
  999.                             yylval.type = f_fields;
  1000.                             return(FIELDS);
  1001.                         }
  1002.     YY_BREAK
  1003. case 52:
  1004. # line 205 "lexer"
  1005. {
  1006.                             yylval.type = f_substr;
  1007.                             return(SUBSTR);
  1008.                         }
  1009.     YY_BREAK
  1010. case 53:
  1011. # line 209 "lexer"
  1012. {
  1013.                             yylval.type = f_system;
  1014.                             return(SYSTEM);
  1015.                         }
  1016.     YY_BREAK
  1017. case 54:
  1018. # line 213 "lexer"
  1019. {
  1020.                             return(WHILE);
  1021.                         }
  1022.     YY_BREAK
  1023. case 55:
  1024. # line 217 "lexer"
  1025. case 56:
  1026. # line 217 "lexer"
  1027. {
  1028.                             yylval.type = op_younger;
  1029.                             return(YOUNGER);
  1030.                         }
  1031.     YY_BREAK
  1032. case 57:
  1033. # line 221 "lexer"
  1034. {
  1035.                             return(INC);
  1036.                         }
  1037.     YY_BREAK
  1038. case 58:
  1039. # line 224 "lexer"
  1040. {
  1041.                             return(DEC);
  1042.                         }
  1043.     YY_BREAK
  1044. case 59:
  1045. # line 227 "lexer"
  1046. {
  1047.                             return(DIV_IS);
  1048.                         }
  1049.     YY_BREAK
  1050. case 60:
  1051. # line 230 "lexer"
  1052. {
  1053.                             return(MINUS_IS);
  1054.                         }
  1055.     YY_BREAK
  1056. case 61:
  1057. # line 233 "lexer"
  1058. {
  1059.                             return(MUL_IS);
  1060.                         }
  1061.     YY_BREAK
  1062. case 62:
  1063. # line 236 "lexer"
  1064. {
  1065.                             return(MOD_IS);
  1066.                         }
  1067.     YY_BREAK
  1068. case 63:
  1069. # line 239 "lexer"
  1070. {
  1071.                             return(PLUS_IS);
  1072.                         }
  1073.     YY_BREAK
  1074. case 64:
  1075. # line 242 "lexer"
  1076. {
  1077.                             return(AND_IS);
  1078.                         }
  1079.     YY_BREAK
  1080. case 65:
  1081. # line 245 "lexer"
  1082. {
  1083.                             return(OR_IS);
  1084.                         }
  1085.     YY_BREAK
  1086. case 66:
  1087. # line 248 "lexer"
  1088. {
  1089.                             return(XOR_IS);
  1090.                         }
  1091.     YY_BREAK
  1092. case 67:
  1093. # line 251 "lexer"
  1094. {
  1095.                             return(SHL_IS);
  1096.                         }
  1097.     YY_BREAK
  1098. case 68:
  1099. # line 254 "lexer"
  1100. {
  1101.                             return(SHR_IS);
  1102.                         }
  1103.     YY_BREAK
  1104. case 69:
  1105. # line 257 "lexer"
  1106. {
  1107.                             return(OR);
  1108.                         }
  1109.     YY_BREAK
  1110. case 70:
  1111. # line 260 "lexer"
  1112. {
  1113.                             return(AND);
  1114.                         }
  1115.     YY_BREAK
  1116. case 71:
  1117. # line 263 "lexer"
  1118. {
  1119.                             return(EQUAL);
  1120.                         }
  1121.     YY_BREAK
  1122. case 72:
  1123. # line 266 "lexer"
  1124. {
  1125.                             return(NOT_EQUAL);
  1126.                         }
  1127.     YY_BREAK
  1128. case 73:
  1129. # line 269 "lexer"
  1130. {
  1131.                             return(SMALLER_EQUAL);
  1132.                         }
  1133.     YY_BREAK
  1134. case 74:
  1135. # line 272 "lexer"
  1136. {
  1137.                             return(GREATER_EQUAL);
  1138.                         }
  1139.     YY_BREAK
  1140. case 75:
  1141. # line 275 "lexer"
  1142. {
  1143.                             return(SHR);
  1144.                         }
  1145.     YY_BREAK
  1146. case 76:
  1147. # line 278 "lexer"
  1148. {
  1149.                             return(SHL);
  1150.                         }
  1151.     YY_BREAK
  1152. case 77:
  1153. # line 281 "lexer"
  1154. {
  1155.                             strcpy(string, yytext);
  1156.                             return(NUMBER);
  1157.                         }
  1158.     YY_BREAK
  1159. case 78:
  1160. # line 286 "lexer"
  1161. case 79:
  1162. # line 286 "lexer"
  1163. {                   /* P_CHECK: value in icm.h */
  1164.                             strcpy(string, "0");
  1165.                             return(NUMBER);
  1166.                         }
  1167.     YY_BREAK
  1168. case 80:
  1169. # line 291 "lexer"
  1170. case 81:
  1171. # line 292 "lexer"
  1172. case 82:
  1173. # line 292 "lexer"
  1174. {
  1175.                             strcpy(string, "1");
  1176.                             return(NUMBER);
  1177.                         }
  1178.     YY_BREAK
  1179. case 83:
  1180. # line 297 "lexer"
  1181. case 84:
  1182. # line 298 "lexer"
  1183. case 85:
  1184. # line 298 "lexer"
  1185. {                   /* O_DIR: value in icm.h */
  1186.                             strcpy(string, "2");
  1187.                             return(NUMBER);
  1188.                         }
  1189.     YY_BREAK
  1190. case 86:
  1191. # line 303 "lexer"
  1192. case 87:
  1193. # line 303 "lexer"
  1194. {                   /* O_SUBDIR: value in icm.h */
  1195.                             strcpy(string, "4");
  1196.                             return(NUMBER);
  1197.                         }
  1198.     YY_BREAK
  1199. case 88:
  1200. # line 308 "lexer"
  1201. case 89:
  1202. # line 308 "lexer"
  1203. {                   /* O_ALL: value in icm.h */
  1204.                             strcpy(string, "8");
  1205.                             return(NUMBER);
  1206.                         }
  1207.     YY_BREAK
  1208. case 90:
  1209. # line 312 "lexer"
  1210. {
  1211.                             strcpy(string, "16");
  1212.                             return(NUMBER);
  1213.                         }
  1214.     YY_BREAK
  1215. case 91:
  1216. # line 316 "lexer"
  1217. {
  1218.                             strcpy(string, "32");
  1219.                             return(NUMBER);
  1220.                         }
  1221.     YY_BREAK
  1222. case 92:
  1223. # line 320 "lexer"
  1224. {
  1225.                             strcpy(string, yytext);
  1226.                             return(IDENTIFIER);
  1227.                         }
  1228.     YY_BREAK
  1229. case 93:
  1230. # line 324 "lexer"
  1231. return(yytext[0]);
  1232.     YY_BREAK
  1233. case 94:
  1234. # line 325 "lexer"
  1235. ECHO;
  1236.     YY_BREAK
  1237. case YY_STATE_EOF(INITIAL):
  1238. case YY_STATE_EOF(str):
  1239.     yyterminate();
  1240.  
  1241.             case YY_END_OF_BUFFER:
  1242.                 {
  1243.                 /* amount of text matched not including the EOB char */
  1244.                 int yy_amount_of_matched_text = yy_cp - yytext - 1;
  1245.  
  1246.                 /* undo the effects of YY_DO_BEFORE_ACTION */
  1247.                 *yy_cp = yy_hold_char;
  1248.  
  1249.                 /* note that here we test for yy_c_buf_p "<=" to the position
  1250.                  * of the first EOB in the buffer, since yy_c_buf_p will
  1251.                  * already have been incremented past the NUL character
  1252.                  * (since all states make transitions on EOB to the end-
  1253.                  * of-buffer state).  Contrast this with the test in yyinput().
  1254.                  */
  1255.                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1256.                     /* this was really a NUL */
  1257.                     {
  1258.                     yy_state_type yy_next_state;
  1259.  
  1260.                     yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1261.  
  1262.                     yy_current_state = yy_get_previous_state();
  1263.  
  1264.                     /* okay, we're now positioned to make the
  1265.                      * NUL transition.  We couldn't have
  1266.                      * yy_get_previous_state() go ahead and do it
  1267.                      * for us because it doesn't know how to deal
  1268.                      * with the possibility of jamming (and we
  1269.                      * don't want to build jamming into it because
  1270.                      * then it will run more slowly)
  1271.                      */
  1272.  
  1273.                     yy_next_state = yy_try_NUL_trans( yy_current_state );
  1274.  
  1275.                     yy_bp = yytext + YY_MORE_ADJ;
  1276.  
  1277.                     if ( yy_next_state )
  1278.                         {
  1279.                         /* consume the NUL */
  1280.                         yy_cp = ++yy_c_buf_p;
  1281.                         yy_current_state = yy_next_state;
  1282.                         goto yy_match;
  1283.                         }
  1284.  
  1285.                     else
  1286.                         {
  1287.                 yy_cp = yy_last_accepting_cpos;
  1288.                 yy_current_state = yy_last_accepting_state;
  1289.                         goto yy_find_action;
  1290.                         }
  1291.                     }
  1292.  
  1293.                 else switch ( yy_get_next_buffer() )
  1294.                     {
  1295.                     case EOB_ACT_END_OF_FILE:
  1296.                         {
  1297.                         yy_did_buffer_switch_on_eof = 0;
  1298.  
  1299.                         if ( yywrap() )
  1300.                             {
  1301.                             /* note: because we've taken care in
  1302.                              * yy_get_next_buffer() to have set up yytext,
  1303.                              * we can now set up yy_c_buf_p so that if some
  1304.                              * total hoser (like flex itself) wants
  1305.                              * to call the scanner after we return the
  1306.                              * YY_NULL, it'll still work - another YY_NULL
  1307.                              * will get returned.
  1308.                              */
  1309.                             yy_c_buf_p = yytext + YY_MORE_ADJ;
  1310.  
  1311.                             yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  1312.                             goto do_action;
  1313.                             }
  1314.  
  1315.                         else
  1316.                             {
  1317.                             if ( ! yy_did_buffer_switch_on_eof )
  1318.                                 YY_NEW_FILE;
  1319.                             }
  1320.                         }
  1321.                         break;
  1322.  
  1323.                     case EOB_ACT_CONTINUE_SCAN:
  1324.                         yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1325.  
  1326.                         yy_current_state = yy_get_previous_state();
  1327.  
  1328.                         yy_cp = yy_c_buf_p;
  1329.                         yy_bp = yytext + YY_MORE_ADJ;
  1330.                         goto yy_match;
  1331.  
  1332.                     case EOB_ACT_LAST_MATCH:
  1333.                         yy_c_buf_p =
  1334.                             &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1335.  
  1336.                         yy_current_state = yy_get_previous_state();
  1337.  
  1338.                         yy_cp = yy_c_buf_p;
  1339.                         yy_bp = yytext + YY_MORE_ADJ;
  1340.                         goto yy_find_action;
  1341.                     }
  1342.                 break;
  1343.                 }
  1344.  
  1345.             default:
  1346. #ifdef FLEX_DEBUG
  1347.                 printf( "action # %d\n", yy_act );
  1348. #endif
  1349.                 YY_FATAL_ERROR(
  1350.                         "fatal flex scanner internal error--no action found" );
  1351.             }
  1352.         }
  1353. #ifdef ICCE_MODIFICATIONS
  1354. /*************************************************************************/
  1355.                                             /* ICCE: BEGIN OF MODIFICATIONS */
  1356.                                             /* (FBB, 12/06/93) */
  1357. #ifdef __cplusplus
  1358.         return (0);                         /* Ms C 7.00: returnvalue */
  1359. #endif                                      /* is required with C++ */
  1360.  
  1361.                                             /* ICCE: END OF MODIFICATION */
  1362. /**************************************************************************/
  1363. #endif
  1364.     }
  1365.  
  1366.  
  1367. /* yy_get_next_buffer - try to read in a new buffer
  1368.  *
  1369.  * synopsis
  1370.  *     int yy_get_next_buffer();
  1371.  *
  1372.  * returns a code representing an action
  1373.  *     EOB_ACT_LAST_MATCH -
  1374.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1375.  *     EOB_ACT_END_OF_FILE - end of file
  1376.  */
  1377.  
  1378. static int yy_get_next_buffer()
  1379.  
  1380.     {
  1381.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  1382.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  1383.     register int number_to_move, i;
  1384.     int ret_val;
  1385.  
  1386.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1387.         YY_FATAL_ERROR(
  1388.                 "fatal flex scanner internal error--end of buffer missed" );
  1389.  
  1390.     /* try to read more data */
  1391.  
  1392.     /* first move last chars to start of buffer */
  1393.     number_to_move = yy_c_buf_p - yytext;
  1394.  
  1395.     for ( i = 0; i < number_to_move; ++i )
  1396.         *(dest++) = *(source++);
  1397.  
  1398.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  1399.         /* don't do the read, it's not guaranteed to return an EOF,
  1400.          * just force an EOF
  1401.          */
  1402.         yy_n_chars = 0;
  1403.  
  1404.     else
  1405.         {
  1406.         int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  1407.  
  1408.         if ( num_to_read > YY_READ_BUF_SIZE )
  1409.             num_to_read = YY_READ_BUF_SIZE;
  1410.  
  1411.         else if ( num_to_read <= 0 )
  1412.             YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  1413.  
  1414.         /* read in more data */
  1415.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1416.                   yy_n_chars, num_to_read );
  1417.         }
  1418.  
  1419.     if ( yy_n_chars == 0 )
  1420.         {
  1421.         if ( number_to_move == 1 )
  1422.             {
  1423.             ret_val = EOB_ACT_END_OF_FILE;
  1424.             yy_current_buffer->yy_eof_status = EOF_DONE;
  1425.             }
  1426.  
  1427.         else
  1428.             {
  1429.             ret_val = EOB_ACT_LAST_MATCH;
  1430.             yy_current_buffer->yy_eof_status = EOF_PENDING;
  1431.             }
  1432.         }
  1433.  
  1434.     else
  1435.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1436.  
  1437.     yy_n_chars += number_to_move;
  1438.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1439.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1440.  
  1441.     /* yytext begins at the second character in yy_ch_buf; the first
  1442.      * character is the one which preceded it before reading in the latest
  1443.      * buffer; it needs to be kept around in case it's a newline, so
  1444.      * yy_get_previous_state() will have with '^' rules active
  1445.      */
  1446.  
  1447.     yytext = &yy_current_buffer->yy_ch_buf[1];
  1448.  
  1449.     return ( ret_val );
  1450.     }
  1451.  
  1452.  
  1453. /* yy_get_previous_state - get the state just before the EOB char was reached
  1454.  *
  1455.  * synopsis
  1456.  *     yy_state_type yy_get_previous_state();
  1457.  */
  1458.  
  1459. static yy_state_type yy_get_previous_state()
  1460.  
  1461.     {
  1462.     register yy_state_type yy_current_state;
  1463.     register YY_CHAR *yy_cp;
  1464.  
  1465.     register YY_CHAR *yy_bp = yytext;
  1466.  
  1467.     yy_current_state = yy_start;
  1468.     if ( yy_bp[-1] == '\n' )
  1469.     ++yy_current_state;
  1470.  
  1471.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1472.         {
  1473.     register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  1474.     if ( yy_accept[yy_current_state] )
  1475.         {
  1476.         yy_last_accepting_state = yy_current_state;
  1477.         yy_last_accepting_cpos = yy_cp;
  1478.         }
  1479.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1480.         {
  1481.         yy_current_state = yy_def[yy_current_state];
  1482.         if ( yy_current_state >= 322 )
  1483.         yy_c = yy_meta[yy_c];
  1484.         }
  1485.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1486.         }
  1487.  
  1488.     return ( yy_current_state );
  1489.     }
  1490.  
  1491.  
  1492. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1493.  *
  1494.  * synopsis
  1495.  *     next_state = yy_try_NUL_trans( current_state );
  1496.  */
  1497.  
  1498. #ifdef YY_USE_PROTOS
  1499. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  1500. #else
  1501. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1502. register yy_state_type yy_current_state;
  1503. #endif
  1504.  
  1505.     {
  1506.     register int yy_is_jam;
  1507.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1508.  
  1509.     register YY_CHAR yy_c = 1;
  1510.     if ( yy_accept[yy_current_state] )
  1511.     {
  1512.     yy_last_accepting_state = yy_current_state;
  1513.     yy_last_accepting_cpos = yy_cp;
  1514.     }
  1515.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1516.     {
  1517.     yy_current_state = yy_def[yy_current_state];
  1518.     if ( yy_current_state >= 322 )
  1519.         yy_c = yy_meta[yy_c];
  1520.     }
  1521.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1522.     yy_is_jam = (yy_current_state == 321);
  1523.  
  1524.     return ( yy_is_jam ? 0 : yy_current_state );
  1525.     }
  1526.  
  1527.  
  1528. #ifdef YY_USE_PROTOS
  1529. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1530. #else
  1531. static void yyunput( c, yy_bp )
  1532. YY_CHAR c;
  1533. register YY_CHAR *yy_bp;
  1534. #endif
  1535.  
  1536.     {
  1537.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1538.  
  1539.     /* undo effects of setting up yytext */
  1540.     *yy_cp = yy_hold_char;
  1541.  
  1542.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1543.         { /* need to shift things up to make room */
  1544.         register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  1545.         register YY_CHAR *dest =
  1546.             &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  1547.         register YY_CHAR *source =
  1548.             &yy_current_buffer->yy_ch_buf[number_to_move];
  1549.  
  1550.         while ( source > yy_current_buffer->yy_ch_buf )
  1551.             *--dest = *--source;
  1552.  
  1553.         yy_cp += dest - source;
  1554.         yy_bp += dest - source;
  1555.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1556.  
  1557.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1558.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1559.         }
  1560.  
  1561.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  1562.         yy_cp[-2] = '\n';
  1563.  
  1564.     *--yy_cp = c;
  1565.  
  1566.     /* note: the formal parameter *must* be called "yy_bp" for this
  1567.      *       macro to now work correctly
  1568.      */
  1569.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1570.     }
  1571.  
  1572.  
  1573. #ifdef __cplusplus
  1574. static int yyinput()
  1575. #else
  1576. static int input()
  1577. #endif
  1578.  
  1579.     {
  1580.     int c;
  1581.     YY_CHAR *yy_cp = yy_c_buf_p;
  1582.  
  1583.     *yy_cp = yy_hold_char;
  1584.  
  1585.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1586.         {
  1587.         /* yy_c_buf_p now points to the character we want to return.
  1588.          * If this occurs *before* the EOB characters, then it's a
  1589.          * valid NUL; if not, then we've hit the end of the buffer.
  1590.          */
  1591.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1592.             /* this was really a NUL */
  1593.             *yy_c_buf_p = '\0';
  1594.  
  1595.         else
  1596.             { /* need more input */
  1597.             yytext = yy_c_buf_p;
  1598.             ++yy_c_buf_p;
  1599.  
  1600.             switch ( yy_get_next_buffer() )
  1601.                 {
  1602.                 case EOB_ACT_END_OF_FILE:
  1603.                     {
  1604.                     if ( yywrap() )
  1605.                         {
  1606.                         yy_c_buf_p = yytext + YY_MORE_ADJ;
  1607.                         return ( EOF );
  1608.                         }
  1609.  
  1610.                     YY_NEW_FILE;
  1611.  
  1612. #ifdef __cplusplus
  1613.                     return ( yyinput() );
  1614. #else
  1615.                     return ( input() );
  1616. #endif
  1617.                     }
  1618.                     break;
  1619.  
  1620.                 case EOB_ACT_CONTINUE_SCAN:
  1621.                     yy_c_buf_p = yytext + YY_MORE_ADJ;
  1622.                     break;
  1623.  
  1624.                 case EOB_ACT_LAST_MATCH:
  1625. #ifdef __cplusplus
  1626.                     YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1627. #else
  1628.                     YY_FATAL_ERROR( "unexpected last match in input()" );
  1629. #endif
  1630.                 }
  1631.             }
  1632.         }
  1633.  
  1634.     c = *yy_c_buf_p;
  1635.     yy_hold_char = *++yy_c_buf_p;
  1636.  
  1637.     return ( c );
  1638.     }
  1639.  
  1640.  
  1641. #ifdef YY_USE_PROTOS
  1642. void yyrestart( FILE *input_file )
  1643. #else
  1644. void yyrestart( input_file )
  1645. FILE *input_file;
  1646. #endif
  1647.  
  1648.     {
  1649.     yy_init_buffer( yy_current_buffer, input_file );
  1650.     yy_load_buffer_state();
  1651.     }
  1652.  
  1653.  
  1654. #ifdef YY_USE_PROTOS
  1655. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1656. #else
  1657. void yy_switch_to_buffer( new_buffer )
  1658. YY_BUFFER_STATE new_buffer;
  1659. #endif
  1660.  
  1661.     {
  1662.     if ( yy_current_buffer == new_buffer )
  1663.         return;
  1664.  
  1665.     if ( yy_current_buffer )
  1666.         {
  1667.         /* flush out information for old buffer */
  1668.         *yy_c_buf_p = yy_hold_char;
  1669.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1670.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1671.         }
  1672.  
  1673.     yy_current_buffer = new_buffer;
  1674.     yy_load_buffer_state();
  1675.  
  1676.     /* we don't actually know whether we did this switch during
  1677.      * EOF (yywrap()) processing, but the only time this flag
  1678.      * is looked at is after yywrap() is called, so it's safe
  1679.      * to go ahead and always set it.
  1680.      */
  1681.     yy_did_buffer_switch_on_eof = 1;
  1682.     }
  1683.  
  1684.  
  1685. #ifdef YY_USE_PROTOS
  1686. void yy_load_buffer_state( void )
  1687. #else
  1688. void yy_load_buffer_state()
  1689. #endif
  1690.  
  1691.     {
  1692.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1693.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1694.     yyin = yy_current_buffer->yy_input_file;
  1695.     yy_hold_char = *yy_c_buf_p;
  1696.     }
  1697.  
  1698.  
  1699. #ifdef YY_USE_PROTOS
  1700. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1701. #else
  1702. YY_BUFFER_STATE yy_create_buffer( file, size )
  1703. FILE *file;
  1704. int size;
  1705. #endif
  1706.  
  1707.     {
  1708.     YY_BUFFER_STATE b;
  1709.  
  1710.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1711.  
  1712.     if ( ! b )
  1713.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1714.  
  1715.     b->yy_buf_size = size;
  1716.  
  1717.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1718.      * we need to put in 2 end-of-buffer characters.
  1719.      */
  1720.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1721.  
  1722.     if ( ! b->yy_ch_buf )
  1723.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1724.  
  1725.     yy_init_buffer( b, file );
  1726.  
  1727.     return ( b );
  1728.     }
  1729.  
  1730.  
  1731. #ifdef YY_USE_PROTOS
  1732. void yy_delete_buffer( YY_BUFFER_STATE b )
  1733. #else
  1734. void yy_delete_buffer( b )
  1735. YY_BUFFER_STATE b;
  1736. #endif
  1737.  
  1738.     {
  1739.     if ( b == yy_current_buffer )
  1740.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1741.  
  1742.     free( (char *) b->yy_ch_buf );
  1743.     free( (char *) b );
  1744.     }
  1745.  
  1746.  
  1747. #ifdef YY_USE_PROTOS
  1748. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1749. #else
  1750. void yy_init_buffer( b, file )
  1751. YY_BUFFER_STATE b;
  1752. FILE *file;
  1753. #endif
  1754.  
  1755.     {
  1756.     b->yy_input_file = file;
  1757.  
  1758.     /* we put in the '\n' and start reading from [1] so that an
  1759.      * initial match-at-newline will be true.
  1760.      */
  1761.  
  1762.     b->yy_ch_buf[0] = '\n';
  1763.     b->yy_n_chars = 1;
  1764.  
  1765.     /* we always need two end-of-buffer characters.  The first causes
  1766.      * a transition to the end-of-buffer state.  The second causes
  1767.      * a jam in that state.
  1768.      */
  1769.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1770.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1771.  
  1772.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1773.  
  1774.     b->yy_eof_status = EOF_NOT_SEEN;
  1775.     }
  1776. # line 325 "lexer"
  1777.